home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 076-100 / 079 / uw / intui.c < prev    next >
C/C++ Source or Header  |  1995-03-13  |  14KB  |  676 lines
  1.  
  2. #include "exec/types.h"
  3. #include "exec/ports.h"
  4. #include "exec/devices.h"
  5. #include "exec/io.h"
  6. #include "exec/memory.h"
  7.  
  8. #include "libraries/dos.h"
  9. #include "graphics/text.h"
  10. #include "libraries/diskfont.h"
  11. #include "intuition/intuition.h"
  12.  
  13. /* Dynamic Intuition Text functions */
  14.  
  15. struct IntuiText *NewIText(text, left, top)
  16. char *text;
  17. int left, top;
  18. {
  19.    struct IntuiText *newtext = NULL;
  20.  
  21.    if (newtext = (struct IntuiText *)AllocMem(sizeof(*newtext),
  22.                                               MEMF_PUBLIC | MEMF_CLEAR))
  23.       {
  24.       newtext->IText = (UBYTE *)text;
  25.       newtext->FrontPen = 0;
  26.       newtext->BackPen = 1;
  27.       newtext->DrawMode = JAM2;
  28.       newtext->LeftEdge = left;
  29.       newtext->TopEdge = top;
  30.       newtext->ITextFont = NULL;
  31.       newtext->NextText = NULL;
  32.       }
  33.    return(newtext);
  34. }
  35.  
  36. struct IntuiText *AddIText(IText, text)
  37. struct IntuiText *IText;
  38. char *text;
  39. {
  40.    struct IntuiText *newtext = NULL;
  41.  
  42.    if (IText) {
  43.       if (newtext = (struct IntuiText *)AllocMem(sizeof(*newtext),
  44.                                                  MEMF_PUBLIC | MEMF_CLEAR))
  45.          {
  46.          newtext->IText = (UBYTE *)text;
  47.             newtext->FrontPen = IText->FrontPen;
  48.          newtext->BackPen  = IText->BackPen;
  49.          newtext->DrawMode = IText->DrawMode;
  50.          newtext->LeftEdge = IText->LeftEdge;
  51.          newtext->TopEdge  = IText->TopEdge + 11;
  52.          newtext->ITextFont = IText->ITextFont;
  53.          newtext->NextText = NULL;
  54.          IText->NextText   = newtext;
  55.          }
  56.       }
  57.    return(newtext);
  58. }
  59.  
  60. DisposeIText(IText)
  61. struct IntuiText *IText;
  62. {
  63.    struct IntuiText *current, *next;
  64.  
  65.    current = IText;
  66.    for(next = current->NextText; current != NULL; next = next->NextText)
  67.       {
  68.       FreeMem(current,sizeof(*current));
  69.       current = next;
  70.       }
  71. }
  72.  
  73.  
  74. /* Dynamic Menu Constructor Functions */
  75.  
  76. #define InterMenuWidth 15
  77.  
  78. struct Menu *NewMenu(menuname, width, height)
  79. char *menuname;
  80. int width, height;
  81. {
  82.    struct Menu *menu = NULL;
  83.  
  84.    if(menu = (struct Menu *)AllocMem(sizeof(*menu),
  85.                                      MEMF_PUBLIC | MEMF_CLEAR))
  86.       {
  87.       menu->NextMenu = NULL;
  88.       menu->LeftEdge = 0;
  89.       menu->TopEdge = 0;
  90.       menu->Width = width;
  91.       menu->Height = height;
  92.       menu->Flags = MENUENABLED;
  93.       menu->MenuName = menuname;
  94.       menu->FirstItem = NULL;
  95.       }
  96.    return(menu);
  97. }
  98.  
  99. struct Menu *AddMenu(menus, MenuName, width, height)
  100. struct Menu *menus;
  101. char *MenuName;
  102. int width, height;
  103. {
  104.    struct Menu *newmenu;
  105.  
  106.    if (menus) {
  107.       if (newmenu = NewMenu(MenuName, width, height)) {
  108.          newmenu->LeftEdge = menus->LeftEdge + menus->Width + InterMenuWidth;
  109.          menus->NextMenu = newmenu;
  110.          }
  111.       }
  112.    return(newmenu);
  113. }
  114.  
  115. struct MenuItem *NewMenuItem(name, width, height)
  116. char *name;
  117. int width, height;
  118. {
  119.    struct MenuItem *newitem = NULL;
  120.    struct IntuiText *NewIText(), *newtext = NULL;
  121.  
  122.    if (newitem = (struct MenuItem *)AllocMem(sizeof(*newitem),
  123.                                              MEMF_PUBLIC | MEMF_CLEAR))
  124.       {
  125.       if (newtext = NewIText(name,0,1)) {
  126.          newitem->NextItem = NULL;
  127.          newitem->ItemFill = (APTR) newtext;
  128.          newitem->LeftEdge = 0;
  129.          newitem->TopEdge = 0;
  130.          newitem->Width = width;
  131.          newitem->Height = height;
  132.          newitem->Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
  133.          newitem->MutualExclude = 0;
  134.          newitem->SelectFill = NULL;
  135.          newitem->Command = 0;
  136.          newitem->SubItem = NULL;
  137.          newitem->NextSelect = 0;
  138.          } else {
  139.          DisposeItem(newitem);
  140.          newitem = NULL;
  141.          }
  142.       }
  143.    return(newitem);
  144. }
  145.  
  146. struct MenuItem *AddNewMenuItem(menu, name, width, height)
  147. struct Menu *menu;
  148. char *name;
  149. int width, height;
  150. {
  151.    struct MenuItem *newitem = NULL, *NewMenuItem();
  152.  
  153.    if (menu) {
  154.       if (newitem = NewMenuItem(name, width, height)) {
  155.          menu->FirstItem = newitem;
  156.          }
  157.       }
  158.    return(newitem);
  159. }
  160.  
  161. struct MenuItem *AddItem(items, name)
  162. struct MenuItem *items;
  163. char *name;
  164. {
  165.    struct MenuItem *newitem = NULL, *NewMenuItem();
  166.  
  167.    if (items) {
  168.       if (newitem = NewMenuItem(name, items->Width, items->Height))
  169.          {
  170.          newitem->TopEdge = items->TopEdge + items->Height;
  171.          newitem->LeftEdge = items->LeftEdge;
  172.          items->NextItem = newitem;
  173.          if (items->MutualExclude) {
  174.             newitem->MutualExclude = (~((~items->MutualExclude) << 1));
  175.             newitem->Flags |= CHECKIT;
  176.             }
  177.          }
  178.       }
  179.    return(newitem);
  180. }
  181.  
  182. struct MenuItem *AddNewSubItem(item, name, width, height)
  183. struct MenuItem *item;
  184. char *name;
  185. int width, height;
  186. {
  187.    struct MenuItem *newitem = NULL, *NewMenuItem();
  188.  
  189.    if (item) {
  190.       if (newitem = NewMenuItem(name, width, height)) {
  191.          item->SubItem = newitem;
  192.          newitem->LeftEdge = item->Width;
  193.          }
  194.       }
  195.    return(newitem);
  196. }
  197.  
  198. DisposeItem(item)
  199. struct MenuItem *item;
  200. {
  201.    DisposeIText((struct ItuiText *)item->ItemFill);
  202.    FreeMem(item,sizeof(*item));
  203. }
  204.  
  205. DisposeItems(items)
  206. struct MenuItem *items;
  207. {
  208.    struct MenuItem *current, *next;
  209.  
  210.    current = items;
  211.    for(next = current->NextItem; current != NULL; next = next->NextItem){
  212.       DisposeItem(current);
  213.       current = next;
  214.    }
  215. }
  216.  
  217. DisposeMenu(menu)
  218. struct Menu *menu;
  219. {
  220.    DisposeItems(menu->FirstItem);
  221.    FreeMem(menu,sizeof(*menu));
  222. }
  223.  
  224. DisposeMenus(menus)
  225. struct Menu *menus;
  226. {
  227.    struct Menu *current, *next;
  228.  
  229.    current = menus;
  230.    for(next = current->NextMenu; current != NULL; next = next->NextMenu){
  231.       DisposeMenu(current);
  232.       current = next;
  233.    }
  234. }
  235.  
  236. /* modified autorequester */
  237.  
  238.  
  239. USHORT   OKBoolV1[18] = {
  240.    0,0,  35,0, 35,17,   0,17,
  241.    0,0,  34,0, 34,17,   1,17, 1,0
  242.    };
  243.  
  244. USHORT OKBoolV2[18] = {
  245.    0,0,  31,0, 31,15,   0,15,
  246.    0,0,  30,0, 30,15,   1,15, 1,0
  247.    };
  248.  
  249. struct Border OKBoolBorder2 = {
  250.    0, 0,
  251.    0, 1, JAM1,
  252.    9,
  253.    OKBoolV2,
  254.    NULL
  255.    };
  256.  
  257. struct Border OKBoolBorder1 = {
  258.    -2, -1,
  259.    3, 1, JAM1,
  260.    9,
  261.    OKBoolV1,
  262.    &OKBoolBorder2
  263.    };
  264.  
  265. struct IntuiText OKText = {
  266.    0, 1, JAM2,
  267.    8, 4,
  268.    NULL,
  269.    "OK",
  270.    NULL
  271.    };
  272.  
  273. struct Gadget OKBoolGadget = {
  274.    NULL,
  275.    -46, -24, 32, 16,
  276.    GADGHCOMP| GRELRIGHT | GRELBOTTOM,
  277.    TOGGLESELECT | RELVERIFY | ENDGADGET,
  278.    BOOLGADGET | REQGADGET,
  279.    (APTR)&OKBoolBorder1,
  280.    NULL,
  281.    &OKText,
  282.    0, NULL, 0, NULL
  283.    };
  284.  
  285. USHORT CancelBoolV1[18] = {
  286.    0,0,  67,0, 67,17,   0,17,
  287.    0,0,  66,0, 66,17,   1,17, 1,0
  288.    };
  289.  
  290. USHORT CancelBoolV2[18] = {
  291.    0,0,  63,0, 63,15,   0,15,
  292.    0,0,  62,0, 62,15,   1,15, 1,0
  293.    };
  294.  
  295. struct Border CancelBoolBorder2 = {
  296.    0, 0,
  297.    0, 1, JAM1,
  298.    9,
  299.    CancelBoolV2,
  300.    NULL
  301.    };
  302.  
  303. struct Border CancelBoolBorder1 = {
  304.    -2, -1,
  305.    3, 1, JAM1,
  306.    9,
  307.    CancelBoolV1,
  308.    &CancelBoolBorder2
  309.    };
  310.  
  311. struct IntuiText CancelText = {
  312.    0, 1, JAM2,
  313.    7, 4,
  314.    NULL,
  315.    "Cancel",
  316.    NULL
  317.    };
  318.  
  319. struct Gadget CancelBoolGadget = {
  320.    NULL,
  321.    14, -24, 64, 16,
  322.    GADGHCOMP| GRELBOTTOM,
  323.    TOGGLESELECT | RELVERIFY | ENDGADGET,
  324.    BOOLGADGET | REQGADGET,
  325.    (APTR)&CancelBoolBorder1,
  326.    NULL,
  327.    &CancelText,
  328.    0, NULL, 0, NULL
  329.    };
  330.  
  331. USHORT ReqV1[18], ReqV2[18];
  332.  
  333. struct Border ReqBorder2 = {
  334.    6, 3,
  335.    0, 1, JAM1,
  336.    9,
  337.    ReqV2,
  338.    NULL
  339.    };
  340.  
  341. struct Border ReqBorder1 = {
  342.    2, 1,
  343.    0, 1, JAM1,
  344.    9,
  345.    ReqV1,
  346.    &ReqBorder2
  347.    };
  348.  
  349. struct Requester autoreq;
  350.  
  351. initrequester(width, height)
  352. int width, height;
  353. {
  354.    ReqV1[0] = 0;
  355.    ReqV1[1] = 0;
  356.    ReqV1[2] = width-5;
  357.    ReqV1[3] = 0;
  358.    ReqV1[4] = width-5;
  359.    ReqV1[5] = height-3;
  360.    ReqV1[6] = 0;
  361.    ReqV1[7] = height-3;
  362.    ReqV1[8] = 0;
  363.    ReqV1[9] = 0;
  364.    ReqV1[10] = width-6;
  365.    ReqV1[11] = 0;
  366.    ReqV1[12] = width-6;
  367.    ReqV1[13] = height-3;
  368.    ReqV1[14] = 1;
  369.    ReqV1[15] = height-3;
  370.    ReqV1[16] = 1;
  371.    ReqV1[17] = 0;
  372.    ReqV2[0] = 0;
  373.    ReqV2[1] = 0;
  374.    ReqV2[2] = width-14;
  375.    ReqV2[3] = 0;
  376.    ReqV2[4] = width-14;
  377.    ReqV2[5] = height-7;
  378.    ReqV2[6] = 0;
  379.    ReqV2[7] = height-7;
  380.    ReqV2[8] = 0;
  381.    ReqV2[9] = 0;
  382.    ReqV2[10] = width-13;
  383.    ReqV2[11] = 0;
  384.    ReqV2[12] = width-13;
  385.    ReqV2[13] = height-7;
  386.    ReqV2[14] = 1;
  387.    ReqV2[15] = height-7;
  388.    ReqV2[16] = 1;
  389.    ReqV2[17] = 0;
  390.    InitRequester(&autoreq);
  391.    autoreq.LeftEdge = (640 - width)/2;
  392.    autoreq.TopEdge = (200 - height)/2;
  393.    autoreq.Width = width;
  394.    autoreq.Height = height;
  395.    autoreq.RelLeft = 0;
  396.    autoreq.RelTop = 0;
  397.    autoreq.ReqBorder = &ReqBorder1;
  398.    autoreq.Flags = NULL;
  399.    autoreq.BackFill = 1;
  400. }
  401.  
  402. autorequest(window, body, cancel, width, height)
  403. struct Window *window;
  404. struct IntuiText *body;
  405. int cancel, width, height;
  406. {
  407.    struct IntuiMessage *IntuiMsg;
  408.    USHORT idcmpflags;            /* holding place for window's flags */
  409.  
  410.    idcmpflags = window->IDCMPFlags;
  411.    window->IDCMPFlags = GADGETUP;
  412.  
  413.    initrequester(width, height);
  414.    autoreq.ReqText = body;
  415.    autoreq.ReqGadget = &OKBoolGadget;
  416.    OKBoolGadget.NextGadget = NULL;
  417.    if (cancel) {
  418.       OnGadget(&CancelBoolGadget, window, &autoreq);
  419.       CancelBoolGadget.Flags = GADGHCOMP | GRELBOTTOM;
  420.       OKBoolGadget.NextGadget = &CancelBoolGadget;
  421.       }
  422.    OKBoolGadget.Flags = GADGHCOMP | GRELRIGHT | GRELBOTTOM;
  423.    OnGadget(&OKBoolGadget, window, &autoreq);
  424.  
  425.    Request(&autoreq, window);
  426.  
  427.    while ((IntuiMsg = (struct IntuiMessage *)
  428.                       GetMsg(window->UserPort)) == 0)
  429.       Wait(1 << window->UserPort->mp_SigBit);
  430.    ReplyMsg(IntuiMsg);
  431.  
  432.    window->IDCMPFlags = idcmpflags;
  433.    return((CancelBoolGadget.Flags & SELECTED) == 0);
  434. }
  435.  
  436. length(s)
  437. char *s;
  438. {
  439.    char *p = s;
  440.  
  441.    while(*p++);
  442.    return(p-s);
  443. }
  444.  
  445. Notify(window, message)
  446. struct Window *window;
  447. char *message;
  448. {
  449.    int c;
  450.    struct IntuiText *MsgText;
  451.  
  452.    MsgText = NewIText(message, 14, 7);
  453.    c = length(message) * 8 + 14;
  454.    autorequest(window, MsgText, FALSE, c, 50);
  455. }
  456.  
  457. Query(window, message)
  458. struct Window *window;
  459. char *message;
  460. {
  461.    int c;
  462.    struct IntuiText *MsgText;
  463.  
  464.    MsgText = NewIText(message, 14, 7);
  465.    c = length(message) * 8 + 14;
  466.    return(autorequest(window, MsgText, TRUE, c, 50));
  467. }
  468.  
  469.  
  470. /*  Standard File Package */
  471.  
  472. USHORT   SaveBoolV1[18] = {
  473.    0,0,  51,0, 51,17,   0,17,
  474.    0,0,  50,0, 50,17,   1,17, 1,0
  475.    };
  476.  
  477. USHORT SaveBoolV2[18] = {
  478.    0,0,  47,0, 47,15,   0,15,
  479.    0,0,  46,0, 46,15,   1,15, 1,0
  480.    };
  481.  
  482. struct Border SaveBoolBorder2 = {
  483.    0, 0,
  484.    0, 1, JAM1,
  485.    9,
  486.    SaveBoolV2,
  487.    NULL
  488.    };
  489.  
  490. struct Border SaveBoolBorder1 = {
  491.    -2, -1,
  492.    3, 1, JAM1,
  493.    9,
  494.    SaveBoolV1,
  495.    &SaveBoolBorder2
  496.    };
  497.  
  498. struct IntuiText SaveText = {
  499.    0, 1, JAM2,
  500.    8, 4,
  501.    NULL,
  502.    "Save",
  503.    NULL
  504.    };
  505.  
  506. struct Gadget SaveBoolGadget = {
  507.    &CancelBoolGadget,
  508.    -62, -24, 48, 16,
  509.    GADGHCOMP| GRELRIGHT | GRELBOTTOM,
  510.    TOGGLESELECT | RELVERIFY | ENDGADGET,
  511.    BOOLGADGET | REQGADGET,
  512.    (APTR)&SaveBoolBorder1,
  513.    NULL,
  514.    &SaveText,
  515.    0, NULL, 0, NULL
  516.    };
  517.  
  518. USHORT   OpenBoolV1[18] = {
  519.    0,0,  51,0, 51,17,   0,17,
  520.    0,0,  50,0, 50,17,   1,17, 1,0
  521.    };
  522.  
  523. USHORT OpenBoolV2[18] = {
  524.    0,0,  47,0, 47,15,   0,15,
  525.    0,0,  46,0, 46,15,   1,15, 1,0
  526.    };
  527.  
  528. struct Border OpenBoolBorder2 = {
  529.    0, 0,
  530.    0, 1, JAM1,
  531.    9,
  532.    OpenBoolV2,
  533.    NULL
  534.    };
  535.  
  536. struct Border OpenBoolBorder1 = {
  537.    -2, -1,
  538.    3, 1, JAM1,
  539.    9,
  540.    OpenBoolV1,
  541.    &OpenBoolBorder2
  542.    };
  543.  
  544. struct IntuiText OpenText = {
  545.    0, 1, JAM2,
  546.    8, 4,
  547.    NULL,
  548.    "Open",
  549.    NULL
  550.    };
  551.  
  552. struct Gadget OpenBoolGadget = {
  553.    &CancelBoolGadget,
  554.    -62, -24, 48, 16,
  555.    GADGHCOMP| GRELRIGHT | GRELBOTTOM,
  556.    TOGGLESELECT | RELVERIFY | ENDGADGET,
  557.    BOOLGADGET | REQGADGET,
  558.    (APTR)&OpenBoolBorder1,
  559.    NULL,
  560.    &OpenText,
  561.    0, NULL, 0, NULL
  562.    };
  563.  
  564. char GFNBuffer[255];
  565. char GFNUBuffer[255];
  566.  
  567. struct StringInfo GFNStrInfo =
  568.    {
  569.    (UBYTE *)GFNBuffer,
  570.    (UBYTE *)GFNUBuffer,
  571.    0, 255, 0,
  572.    0, 0, 0, 0, 0,
  573.    NULL, 0, NULL
  574.    };
  575.  
  576. struct Gadget GFNStrGad =
  577.    {
  578.    NULL,
  579.    14, 19, 270, 11,
  580.    GADGHCOMP | SELECTED,
  581.    RELVERIFY | ENDGADGET,
  582.    STRGADGET | REQGADGET,
  583.    NULL,       /* Border */
  584.    NULL,
  585.    NULL,       /* To point to Gadget text */
  586.    0,
  587.    (APTR)&GFNStrInfo,
  588.    0, NULL
  589.    };
  590.  
  591. GFN(window, openflag, message)
  592. struct Window *window;
  593. int openflag;
  594. char *message;
  595. {
  596.    struct IntuiText *GFNText, *NewIText(), *AddIText();
  597.    struct IntuiMessage *IntuiMsg;
  598.  
  599.    GFNText = NewIText( message, 14, 7);
  600.    initrequester(300, 60);
  601.    autoreq.ReqText = GFNText;
  602.  
  603.    autoreq.ReqGadget = &GFNStrGad;
  604.    if (openflag) {
  605.       GFNStrGad.NextGadget = &OpenBoolGadget;
  606.       OnGadget(&OpenBoolGadget, window, &autoreq);
  607.       OpenBoolGadget.Flags = GADGHCOMP | GRELBOTTOM | GRELRIGHT;
  608.       } else {
  609.       GFNStrGad.NextGadget = &SaveBoolGadget;
  610.       OnGadget(&SaveBoolGadget, window, &autoreq);
  611.       SaveBoolGadget.Flags = GADGHCOMP | GRELBOTTOM | GRELRIGHT;
  612.       }
  613.    OnGadget(&GFNStrGad, window, &autoreq);
  614.    OnGadget(&CancelBoolGadget, window, &autoreq);
  615.    CancelBoolGadget.Flags = GADGHCOMP | GRELBOTTOM;
  616.  
  617.    Request(&autoreq, window);
  618.    while ((IntuiMsg = (struct IntuiMessage *)GetMsg(window->UserPort)) == 0)
  619.       Wait(1 << window->UserPort->mp_SigBit);
  620.    ReplyMsg(IntuiMsg);
  621.    DisposeIText(GFNText);
  622.    return((CancelBoolGadget.Flags & SELECTED) == 0);
  623. }
  624.  
  625. struct FileHandle *OpenFile(window, prompt)
  626. struct Window *window;
  627. char *prompt;
  628. {
  629.    struct FileLock *lock, *Lock();
  630.    struct FileHandle *file, *Open();
  631.  
  632.    if (GFN(window, TRUE, prompt)) {
  633.       UnLock(lock = Lock(GFNBuffer, ACCESS_READ));
  634.       if (lock != 0) {
  635.          file = Open(GFNBuffer, MODE_OLDFILE);
  636.          if (file != 0) {
  637.             return(file);
  638.             }
  639.          Notify(window, "Can't open file.");
  640.          return(NULL);
  641.          }
  642.       Notify(window, "File not found.");
  643.    }
  644.    return(NULL);
  645. }
  646.  
  647. struct FileHandle *SaveFile(window, prompt)
  648. struct Window *window;
  649. char *prompt;
  650. {
  651.    struct FileLock *lock, *Lock();
  652.    struct FileHandle *file, *Open();
  653.  
  654.    if(GFN(window, FALSE, prompt)) {
  655.       UnLock(lock = Lock(GFNBuffer, ACCESS_WRITE));
  656.       if (lock == 0) {
  657.          file = Open(GFNBuffer, MODE_NEWFILE);
  658.          if (file != 0) {
  659.             return(file);
  660.             }
  661.          Notify(window,"Can't open file.");
  662.          return(NULL);
  663.          }
  664.       if (Query(window,"Overwrite file?")) {
  665.          file = Open(GFNBuffer, MODE_NEWFILE);
  666.          if (file != 0) {
  667.             return(file);
  668.             }
  669.          Notify(window,"Can't open file.", 14, 7);
  670.          return(NULL);
  671.          }
  672.       }
  673.    return(NULL);
  674. }
  675.  
  676.